【HDU5573 2015上海赛区B】【构造二进制思想】Binary Tree 二叉树上走m层加减数使得最后权值恰为n

最新推荐文章于 2022-08-06 16:11:36 发布

snowy_smile

最新推荐文章于 2022-08-06 16:11:36 发布

阅读量1.3k

点赞数

分类专栏：题库-HDU 构造文章标签：题库-HDU 构造

本文链接：https://blog.csdn.net/snowy_smile/article/details/50094987

版权

题库-HDU 同时被 2 个专栏收录

144 篇文章 0 订阅

订阅专栏

构造

24 篇文章 0 订阅

订阅专栏

Binary Tree

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 42 Accepted Submission(s): 25
Special Judge

Problem Description

The Old Frog King lives on the root of an infinite tree. According to the law, each node should connect to exactly two nodes on the next level, forming a full binary tree.

Since the king is professional in math, he sets a number to each node. Specifically, the root of the tree, where the King lives, is

1 . Say

froot=1 .

And for each node

u , labels as

fu , the left child is

fu×2 and right child is

fu×2+1 . The king looks at his tree kingdom, and feels satisfied.

Time flies, and the frog king gets sick. According to the old dark magic, there is a way for the king to live for another

N years, only if he could collect exactly

N soul gems.

Initially the king has zero soul gems, and he is now at the root. He will walk down, choosing left or right child to continue. Each time at node

x , the number at the node is

fx (remember

froot=1 ), he can choose to increase his number of soul gem by

fx , or decrease it by

fx .

He will walk from the root, visit exactly

K nodes (including the root), and do the increasement or decreasement as told. If at last the number is

N , then he will succeed.

Noting as the soul gem is some kind of magic, the number of soul gems the king has could be negative.

Given

N ,

K , help the King find a way to collect exactly

N soul gems by visiting exactly

K nodes.

Input

First line contains an integer

T , which indicates the number of test cases.

Every test case contains two integers

N and

K , which indicates soul gems the frog king want to collect and number of nodes he can visit.

⋅

1≤T≤100 .

⋅

1≤N≤109 .

⋅

N≤2K≤260 .

Output

For every test case, you should output " Case #x:" first, where

x indicates the case number and counts from

1 .

Then

K lines follows, each line is formated as 'a b', where

a is node label of the node the frog visited, and

b is either '+' or '-' which means he increases / decreases his number by

a .

It's guaranteed that there are at least one solution and if there are more than one solutions, you can output any of them.

Sample Input

Sample Output

      
      
       
       Case #1:
1 +
3 -
7 +
Case #2:
1 +
3 +
6 -
12 +

Source

2015ACM/ICPC亚洲区上海站-重现赛（感谢华东理工）

Sample Input

Sample Output

  
  
   
   Case #1:
1 +
3 -
7 +
Case #2:
1 +
3 +
6 -
12 +

Source

2015ACM/ICPC亚洲区上海站-重现赛（感谢华东理工）

代码简化版499B：

#include<stdio.h>
#include<string.h>
int casenum,casei;
int n,m;
long long b[64],s[64],num[64];
int main()
{
	for(int i=1;i<=62;++i)b[i]=1ll<<i-1;
	for(int i=0;i<=62;++i)s[i]=(1ll<<i)-1;
	scanf("%d",&casenum);
	for(casei=1;casei<=casenum;++casei)
	{
		scanf("%d%d",&n,&m);
		printf("Case #%d:\n",casei);
		memcpy(num,b,sizeof(b));
		long long dif=s[m]-n;
		if(dif&1){++dif;++num[m];}
		dif>>=1;
		for(int i=1;i<=m;++i)printf("%lld %c\n",num[i],dif&b[i]?'-':'+');
	}
	return 0;
}

代码完整版：

#include<stdio.h>
#include<string.h>
#include<ctype.h>
#include<math.h>
#include<iostream>
#include<string>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<bitset>
#include<algorithm>
#include<time.h>
using namespace std;
void fre(){freopen("c://test//input.in","r",stdin);freopen("c://test//output.out","w",stdout);}
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T1,class T2>inline void gmax(T1 &a,T2 b){if(b>a)a=b;}
template <class T1,class T2>inline void gmin(T1 &a,T2 b){if(b<a)a=b;}
const int N=0,M=0,Z=1e9+7,ms63=1061109567;
int casenum,casei;
int n,m;
LL b[64],s[64],num[64];
int main()
{
	for(int i=1;i<=62;++i)b[i]=1ll<<i-1;
	for(int i=0;i<=62;++i)s[i]=(1ll<<i)-1;
	scanf("%d",&casenum);
	for(casei=1;casei<=casenum;++casei)
	{
		scanf("%d%d",&n,&m);
		printf("Case #%d:\n",casei);
		MC(num,b);
		LL dif=s[m]-n;
		if(dif&1){++dif;++num[m];}
		dif>>=1;
		for(int i=1;i<=m;++i)printf("%lld %c\n",num[i],dif&b[i]?'-':'+');
	}
	return 0;
}
/*
【trick&&吐槽】
读题顺序很重要，傻叉题要早点做呀！

【题意】
给你一棵满二叉树，节点按照常规方式做编号，即以1为根，i号节点的左右子节点分别是2i和2i+1
然后有T（100）组数据。
对于每组数据，给你n（1<=n<=1e9）和m（n<=2^m<=60，即log(n)<=m<=60）。
在这棵树上，每个节点可以走到左儿子或右儿子，走到i号节点时，我们可以选择+或-这个节点的权值。
让你现在从深度1走到深度m，一共走过m个节点，适当选择路径及加减，使得最终的权值恰好为n

【类型】
构造 二进制思想

【分析】
构造题至少还是应该画一画。
而当我们画完满二叉树，就会发现，这棵树最左侧恰好是1，2，4，8，16……
而且题目是考虑数的构造，于是我们很自然地想到二进制做法。即，只走最左的链。

然而，和传统二进制构成的区别是，传统二进制是选和不选；这个是加或者减。
而且，只走m层，都是走最左侧，取的数是最小的，会不会比目标要求要小呢？
对于前m层，只走最左侧，数的和是2^m-1，然而n最大时，是可能为2^m的。
就只有一个点的情况没有覆盖，于是，对于这种情况，我们直接选择最后一个层走到2^(m-1)+1即可。

这样，如果都是加法的话，显然路径上的权值会不小于n啦。
于是，问题变成了。多出来的怎么办？

我们要使得路径上的一些'+'变成'-'。然而，这个变更，使得数字每次都是减少偶数。
于是，除了上述提到的n==2^m这种情况之外，定义dif=(2^m-1)-n.
如果dif为奇数，那么我们就在最后一层右移一位，使得现有数和目标数拥有同样的奇偶性。
然后，我们要变'+'为'-'的数值，就是dif>>1了。
而显然，因为n至少为1，所以，这个数值最大也必然小于2^(m-1)，也就是说，这个数值的构造是可以在前m-1层完成。
前m-1层只有2进制数。dif有某个二进制数的话，就在当为变'+'为'-'即可啦。

这样，这道题就可以AC了。
结合二进制思想，是可以瞬间想到想法的基础构造题呢。

【时间复杂度&&优化】
O(Tm)

*/

snowy_smile

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【HDU5573 2015上海赛区B】【构造二进制思想】Binary Tree 二叉树上走m层加减数使得最后权值恰为n

Binary TreeTime Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)Total Submission(s): 42 Accepted Submission(s): 25Special JudgeProblem DescriptionThe Old F
复制链接

扫一扫